package demo1;


import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Test2 {











    //复制带随机指针的链表
    /*public Node copyRandomList(Node head) {
        Map<Node,Node> map = new HashMap<>();
        Node cur = head;
        //1. 第一次遍历链表 存储对应关系
        while(cur != null) {
            Node node = new Node(cur.val);
            map.put(cur,node);
            cur = cur.next;
        }
        //2. 第2次遍历链表 开始修改每个节点的指向
        cur = head;
        while(cur != null) {
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }
        //3. 返回head对应的地址
        return map.get(head);
    }*/









    //坏键盘打字
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        //while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str1 = in.nextLine(); //理想输入的
            String str2 = in.nextLine(); //实际输入的
            func(str1, str2);

        //}
    }
    public static void func(String str1, String str2) {
        Set<Character> set = new HashSet<>();
        for (char ch : str2.toUpperCase().toCharArray()) { //先变成大写，然后在转化为数组
            set.add(ch);
        }

        Set<Character> set2 = new HashSet<>();
        for (char ch : str1.toUpperCase().toCharArray()) {
            if (!set.contains(ch) && !set2.contains(ch)) {
                set2.add(ch);
                System.out.print(ch);
            }
        }
    }


    //宝石与石头
    public int numJewelsInStones(String jewels, String stones) {
        Set<Character> set = new HashSet<>();
        /*for (int i = 0; i < jewels.length(); i++) {
            char ch = jewels.charAt(i);
            set.add(ch);
        }*/
        char[] array = jewels.toCharArray();
        for (char ch : array) {
            set.add(ch);
        }
        int count = 0;
        for (int i = 0; i < stones.length(); i++) {
            char ch = stones.charAt(i);
            if (set.contains(ch)) {
                count++;
            }
        }
        return count;
    }


    //只出现一次的数字
    public int singleNumber(int[] nums) {
        //使用Set集合
        Set<Integer> set = new HashSet<>();
        //Set<Integer> set = new TreeSet<>();
        for (int x : nums) {
            if (!set.contains(x)) {
                set.add(x);
            } else {
                set.remove(x);
            }
        }
        //此时set集合当中都是只出现一次的元素
        for (int x : set) {
            return x;
        }
        return -1;


    /*
    //使用Map
    Map<Integer, Integer> map = new HashMap<>();
    //Map<Integer, Integer> map = new TreeMap<>();
    for(int x : nums) {
        if(map.get(x) != null) {
            map.remove(x);
        } else {
            map.put(x,1);
        }
    }
    //此时map中的键值对都是只出现一次的元素，返回map中的所有key
    for(Map.Entry<Integer,Integer> entry : map.entrySet()) {
        return entry.getKey();
    }

    //Set<Integer> set = map.keySet();
    //for(Integer x : set) {
    //    return x;
    //}
    return -1;
    */
    }


}
